home *** CD-ROM | disk | FTP | other *** search
/ PD Collection CD 1 / PD Collection CD 1.iso / textual / tex / files / !tex / TeXsource / web2ctex / ctex / c / tex4 < prev    next >
Encoding:
Text File  |  1988-05-19  |  45.8 KB  |  2,026 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. zcharwarning ( f , c ) 
  5. internalfontnumber f ; 
  6. eightbits c ; 
  7. {charwarning_regmem 
  8.   if ( eqtb [ 5302 ] .cint > 0 ) 
  9.   {
  10.     begindiagnostic () ; 
  11.     printnl ( 678 ) ; 
  12.     printASCII ( c ) ; 
  13.     print ( 679 ) ; 
  14.     print ( fontname [ f ] ) ; 
  15.     printchar ( 33 ) ; 
  16.     enddiagnostic ( false ) ; 
  17.   } 
  18. } 
  19. halfword znewcharacter ( f , c ) 
  20. internalfontnumber f ; 
  21. eightbits c ; 
  22. {/* 10 */ register halfword Result; newcharacter_regmem 
  23.   halfword p  ; 
  24.   if ( fontbc [ f ] <= c ) 
  25.   if ( fontec [ f ] >= c ) 
  26.   if ( ( fontinfo [ charbase [ f ] + c ] .qqqq .b0 > 0 ) ) 
  27.   {
  28.     p = getavail () ; 
  29.     mem [ p ] .hh.b0 = f ; 
  30.     mem [ p ] .hh.b1 = c ; 
  31.     Result = p ; 
  32.     return(Result) ; 
  33.   } 
  34.   charwarning ( f , c ) ; 
  35.   Result = 0 ; 
  36.   return(Result) ; 
  37. } 
  38. dviswap () {
  39.     dviswap_regmem 
  40.   if ( dvilimit == dvibufsize ) 
  41.   {
  42.     writedvi ( 0 , halfbuf - 1 ) ; 
  43.     dvilimit = halfbuf ; 
  44.     dvioffset = dvioffset + dvibufsize ; 
  45.     dviptr = 0 ; 
  46.   } 
  47.   else {
  48.       
  49.     writedvi ( halfbuf , dvibufsize - 1 ) ; 
  50.     dvilimit = dvibufsize ; 
  51.   } 
  52.   dvigone = dvigone + halfbuf ; 
  53. } 
  54. zdvifour ( x ) 
  55. integer x ; 
  56. {dvifour_regmem 
  57.   if ( x >= 0 ) 
  58.   {
  59.     dvibuf [ dviptr ] = x / 16777216L ; 
  60.     incr ( dviptr ) ; 
  61.     if ( dviptr == dvilimit ) 
  62.     dviswap () ; 
  63.   } 
  64.   else {
  65.       
  66.     x = x + 1073741824L ; 
  67.     x = x + 1073741824L ; 
  68.     {
  69.       dvibuf [ dviptr ] = ( x / 16777216L ) + 128 ; 
  70.       incr ( dviptr ) ; 
  71.       if ( dviptr == dvilimit ) 
  72.       dviswap () ; 
  73.     } 
  74.   } 
  75.   x = x % 16777216L ; 
  76.   {
  77.     dvibuf [ dviptr ] = x / 65536L ; 
  78.     incr ( dviptr ) ; 
  79.     if ( dviptr == dvilimit ) 
  80.     dviswap () ; 
  81.   } 
  82.   x = x % 65536L ; 
  83.   {
  84.     dvibuf [ dviptr ] = x / 256 ; 
  85.     incr ( dviptr ) ; 
  86.     if ( dviptr == dvilimit ) 
  87.     dviswap () ; 
  88.   } 
  89.   {
  90.     dvibuf [ dviptr ] = x % 256 ; 
  91.     incr ( dviptr ) ; 
  92.     if ( dviptr == dvilimit ) 
  93.     dviswap () ; 
  94.   } 
  95. } 
  96. zdvipop ( l ) 
  97. integer l ; 
  98. {dvipop_regmem 
  99.   if ( ( l == dvioffset + dviptr ) && ( dviptr > 0 ) ) 
  100.   decr ( dviptr ) ; 
  101.   else {
  102.       
  103.     dvibuf [ dviptr ] = 142 ; 
  104.     incr ( dviptr ) ; 
  105.     if ( dviptr == dvilimit ) 
  106.     dviswap () ; 
  107.   } 
  108. } 
  109. zdvifontdef ( f ) 
  110. internalfontnumber f ; 
  111. {dvifontdef_regmem 
  112.   poolpointer k  ; 
  113.   {
  114.     dvibuf [ dviptr ] = 243 ; 
  115.     incr ( dviptr ) ; 
  116.     if ( dviptr == dvilimit ) 
  117.     dviswap () ; 
  118.   } 
  119.   {
  120.     dvibuf [ dviptr ] = f - 1 ; 
  121.     incr ( dviptr ) ; 
  122.     if ( dviptr == dvilimit ) 
  123.     dviswap () ; 
  124.   } 
  125.   {
  126.     dvibuf [ dviptr ] = fontcheck [ f ] .b0 ; 
  127.     incr ( dviptr ) ; 
  128.     if ( dviptr == dvilimit ) 
  129.     dviswap () ; 
  130.   } 
  131.   {
  132.     dvibuf [ dviptr ] = fontcheck [ f ] .b1 ; 
  133.     incr ( dviptr ) ; 
  134.     if ( dviptr == dvilimit ) 
  135.     dviswap () ; 
  136.   } 
  137.   {
  138.     dvibuf [ dviptr ] = fontcheck [ f ] .b2 ; 
  139.     incr ( dviptr ) ; 
  140.     if ( dviptr == dvilimit ) 
  141.     dviswap () ; 
  142.   } 
  143.   {
  144.     dvibuf [ dviptr ] = fontcheck [ f ] .b3 ; 
  145.     incr ( dviptr ) ; 
  146.     if ( dviptr == dvilimit ) 
  147.     dviswap () ; 
  148.   } 
  149.   dvifour ( fontsize [ f ] ) ; 
  150.   dvifour ( fontdsize [ f ] ) ; 
  151.   {
  152.     dvibuf [ dviptr ] = ( strstart [ fontarea [ f ] + 1 ] - strstart [ 
  153.     fontarea [ f ] ] ) ; 
  154.     incr ( dviptr ) ; 
  155.     if ( dviptr == dvilimit ) 
  156.     dviswap () ; 
  157.   } 
  158.   {
  159.     dvibuf [ dviptr ] = ( strstart [ fontname [ f ] + 1 ] - strstart [ 
  160.     fontname [ f ] ] ) ; 
  161.     incr ( dviptr ) ; 
  162.     if ( dviptr == dvilimit ) 
  163.     dviswap () ; 
  164.   } 
  165.   {register integer for_end; k = strstart [ fontarea [ f ] ] ; for_end = 
  166.   strstart [ fontarea [ f ] + 1 ] - 1 ; if ( k <= for_end) do 
  167.     {
  168.       dvibuf [ dviptr ] = strpool [ k ] ; 
  169.       incr ( dviptr ) ; 
  170.       if ( dviptr == dvilimit ) 
  171.       dviswap () ; 
  172.     } 
  173.   while ( k++ < for_end ) ; } 
  174.   {register integer for_end; k = strstart [ fontname [ f ] ] ; for_end = 
  175.   strstart [ fontname [ f ] + 1 ] - 1 ; if ( k <= for_end) do 
  176.     {
  177.       dvibuf [ dviptr ] = strpool [ k ] ; 
  178.       incr ( dviptr ) ; 
  179.       if ( dviptr == dvilimit ) 
  180.       dviswap () ; 
  181.     } 
  182.   while ( k++ < for_end ) ; } 
  183. } 
  184. zmovement ( w , o ) 
  185. scaled w ; 
  186. eightbits o ; 
  187. {/* 10 40 45 2 1 */ movement_regmem 
  188.   smallnumber mstate  ; 
  189.   halfword p, q  ; 
  190.   integer k  ; 
  191.   q = getnode ( 3 ) ; 
  192.   mem [ q + 1 ] .cint = w ; 
  193.   mem [ q + 2 ] .cint = dvioffset + dviptr ; 
  194.   if ( o == 157 ) 
  195.   {
  196.     mem [ q ] .hh .v.RH = downptr ; 
  197.     downptr = q ; 
  198.   } 
  199.   else {
  200.       
  201.     mem [ q ] .hh .v.RH = rightptr ; 
  202.     rightptr = q ; 
  203.   } 
  204.   p = mem [ q ] .hh .v.RH ; 
  205.   mstate = 0 ; 
  206.   while ( p != 0 ) {
  207.       
  208.     if ( mem [ p + 1 ] .cint == w ) 
  209.     switch ( mstate + mem [ p ] .hh .v.LH ) 
  210.     {case 3 : 
  211.     case 4 : 
  212.     case 15 : 
  213.     case 16 : 
  214.       if ( mem [ p + 2 ] .cint < dvigone ) 
  215.       goto lab45 ; 
  216.       else {
  217.       
  218.     k = mem [ p + 2 ] .cint - dvioffset ; 
  219.     if ( k < 0 ) 
  220.     k = k + dvibufsize ; 
  221.     dvibuf [ k ] = dvibuf [ k ] + 5 ; 
  222.     mem [ p ] .hh .v.LH = 1 ; 
  223.     goto lab40 ; 
  224.       } 
  225.       break ; 
  226.     case 5 : 
  227.     case 9 : 
  228.     case 11 : 
  229.       if ( mem [ p + 2 ] .cint < dvigone ) 
  230.       goto lab45 ; 
  231.       else {
  232.       
  233.     k = mem [ p + 2 ] .cint - dvioffset ; 
  234.     if ( k < 0 ) 
  235.     k = k + dvibufsize ; 
  236.     dvibuf [ k ] = dvibuf [ k ] + 10 ; 
  237.     mem [ p ] .hh .v.LH = 2 ; 
  238.     goto lab40 ; 
  239.       } 
  240.       break ; 
  241.     case 1 : 
  242.     case 2 : 
  243.     case 8 : 
  244.     case 13 : 
  245.       goto lab40 ; 
  246.       break ; 
  247.       default: 
  248.       ; 
  249.       break ; 
  250.     } 
  251.     else switch ( mstate + mem [ p ] .hh .v.LH ) 
  252.     {case 1 : 
  253.       mstate = 6 ; 
  254.       break ; 
  255.     case 2 : 
  256.       mstate = 12 ; 
  257.       break ; 
  258.     case 8 : 
  259.     case 13 : 
  260.       goto lab45 ; 
  261.       break ; 
  262.       default: 
  263.       ; 
  264.       break ; 
  265.     } 
  266.     p = mem [ p ] .hh .v.RH ; 
  267.   } 
  268.   lab45: ; 
  269.   mem [ q ] .hh .v.LH = 3 ; 
  270.   if ( abs ( w ) >= 8388608L ) 
  271.   {
  272.     {
  273.       dvibuf [ dviptr ] = o + 3 ; 
  274.       incr ( dviptr ) ; 
  275.       if ( dviptr == dvilimit ) 
  276.       dviswap () ; 
  277.     } 
  278.     dvifour ( w ) ; 
  279.     return ; 
  280.   } 
  281.   if ( abs ( w ) >= 32768L ) 
  282.   {
  283.     {
  284.       dvibuf [ dviptr ] = o + 2 ; 
  285.       incr ( dviptr ) ; 
  286.       if ( dviptr == dvilimit ) 
  287.       dviswap () ; 
  288.     } 
  289.     if ( w < 0 ) 
  290.     w = w + 16777216L ; 
  291.     {
  292.       dvibuf [ dviptr ] = w / 65536L ; 
  293.       incr ( dviptr ) ; 
  294.       if ( dviptr == dvilimit ) 
  295.       dviswap () ; 
  296.     } 
  297.     w = w % 65536L ; 
  298.     goto lab2 ; 
  299.   } 
  300.   if ( abs ( w ) >= 128 ) 
  301.   {
  302.     {
  303.       dvibuf [ dviptr ] = o + 1 ; 
  304.       incr ( dviptr ) ; 
  305.       if ( dviptr == dvilimit ) 
  306.       dviswap () ; 
  307.     } 
  308.     if ( w < 0 ) 
  309.     w = w + 65536L ; 
  310.     goto lab2 ; 
  311.   } 
  312.   {
  313.     dvibuf [ dviptr ] = o ; 
  314.     incr ( dviptr ) ; 
  315.     if ( dviptr == dvilimit ) 
  316.     dviswap () ; 
  317.   } 
  318.   if ( w < 0 ) 
  319.   w = w + 256 ; 
  320.   goto lab1 ; 
  321.   lab2: {
  322.       
  323.     dvibuf [ dviptr ] = w / 256 ; 
  324.     incr ( dviptr ) ; 
  325.     if ( dviptr == dvilimit ) 
  326.     dviswap () ; 
  327.   } 
  328.   lab1: {
  329.       
  330.     dvibuf [ dviptr ] = w % 256 ; 
  331.     incr ( dviptr ) ; 
  332.     if ( dviptr == dvilimit ) 
  333.     dviswap () ; 
  334.   } 
  335.   return ; 
  336.   lab40: mem [ q ] .hh .v.LH = mem [ p ] .hh .v.LH ; 
  337.   if ( mem [ q ] .hh .v.LH == 1 ) 
  338.   {
  339.     {
  340.       dvibuf [ dviptr ] = o + 4 ; 
  341.       incr ( dviptr ) ; 
  342.       if ( dviptr == dvilimit ) 
  343.       dviswap () ; 
  344.     } 
  345.     while ( mem [ q ] .hh .v.RH != p ) {
  346.     
  347.       q = mem [ q ] .hh .v.RH ; 
  348.       switch ( mem [ q ] .hh .v.LH ) 
  349.       {case 3 : 
  350.     mem [ q ] .hh .v.LH = 5 ; 
  351.     break ; 
  352.       case 4 : 
  353.     mem [ q ] .hh .v.LH = 6 ; 
  354.     break ; 
  355.     default: 
  356.     ; 
  357.     break ; 
  358.       } 
  359.     } 
  360.   } 
  361.   else {
  362.       
  363.     {
  364.       dvibuf [ dviptr ] = o + 9 ; 
  365.       incr ( dviptr ) ; 
  366.       if ( dviptr == dvilimit ) 
  367.       dviswap () ; 
  368.     } 
  369.     while ( mem [ q ] .hh .v.RH != p ) {
  370.     
  371.       q = mem [ q ] .hh .v.RH ; 
  372.       switch ( mem [ q ] .hh .v.LH ) 
  373.       {case 3 : 
  374.     mem [ q ] .hh .v.LH = 4 ; 
  375.     break ; 
  376.       case 5 : 
  377.     mem [ q ] .hh .v.LH = 6 ; 
  378.     break ; 
  379.     default: 
  380.     ; 
  381.     break ; 
  382.       } 
  383.     } 
  384.   } 
  385. } 
  386. zprunemovements ( l ) 
  387. integer l ; 
  388. {/* 30 10 */ prunemovements_regmem 
  389.   halfword p  ; 
  390.   while ( downptr != 0 ) {
  391.       
  392.     if ( mem [ downptr + 2 ] .cint < l ) 
  393.     goto lab30 ; 
  394.     p = downptr ; 
  395.     downptr = mem [ p ] .hh .v.RH ; 
  396.     freenode ( p , 3 ) ; 
  397.   } 
  398.   lab30: while ( rightptr != 0 ) {
  399.       
  400.     if ( mem [ rightptr + 2 ] .cint < l ) 
  401.     return ; 
  402.     p = rightptr ; 
  403.     rightptr = mem [ p ] .hh .v.RH ; 
  404.     freenode ( p , 3 ) ; 
  405.   } 
  406. } 
  407. zspecialout ( p ) 
  408. halfword p ; 
  409. {specialout_regmem 
  410.   schar oldsetting  ; 
  411.   poolpointer k  ; 
  412.   if ( curh != dvih ) 
  413.   {
  414.     movement ( curh - dvih , 143 ) ; 
  415.     dvih = curh ; 
  416.   } 
  417.   if ( curv != dviv ) 
  418.   {
  419.     movement ( curv - dviv , 157 ) ; 
  420.     dviv = curv ; 
  421.   } 
  422.   oldsetting = selector ; 
  423.   selector = 21 ; 
  424.   showtokenlist ( mem [ mem [ p + 1 ] .hh .v.RH ] .hh .v.RH , 0 , poolsize - 
  425.   poolptr ) ; 
  426.   selector = oldsetting ; 
  427.   {
  428.     if ( poolptr + 1 > poolsize ) 
  429.     overflow ( 128 , poolsize - initpoolptr ) ; 
  430.   } 
  431.   if ( ( poolptr - strstart [ strptr ] ) < 256 ) 
  432.   {
  433.     {
  434.       dvibuf [ dviptr ] = 239 ; 
  435.       incr ( dviptr ) ; 
  436.       if ( dviptr == dvilimit ) 
  437.       dviswap () ; 
  438.     } 
  439.     {
  440.       dvibuf [ dviptr ] = ( poolptr - strstart [ strptr ] ) ; 
  441.       incr ( dviptr ) ; 
  442.       if ( dviptr == dvilimit ) 
  443.       dviswap () ; 
  444.     } 
  445.   } 
  446.   else {
  447.       
  448.     {
  449.       dvibuf [ dviptr ] = 242 ; 
  450.       incr ( dviptr ) ; 
  451.       if ( dviptr == dvilimit ) 
  452.       dviswap () ; 
  453.     } 
  454.     dvifour ( ( poolptr - strstart [ strptr ] ) ) ; 
  455.   } 
  456.   {register integer for_end; k = strstart [ strptr ] ; for_end = poolptr - 1 
  457.   ; if ( k <= for_end) do 
  458.     {
  459.       dvibuf [ dviptr ] = strpool [ k ] ; 
  460.       incr ( dviptr ) ; 
  461.       if ( dviptr == dvilimit ) 
  462.       dviswap () ; 
  463.     } 
  464.   while ( k++ < for_end ) ; } 
  465.   poolptr = strstart [ strptr ] ; 
  466. } 
  467. zwriteout ( p ) 
  468. halfword p ; 
  469. {writeout_regmem 
  470.   schar oldsetting  ; 
  471.   integer oldmode  ; 
  472.   smallnumber j  ; 
  473.   halfword q, r  ; 
  474.   q = getavail () ; 
  475.   mem [ q ] .hh .v.LH = 637 ; 
  476.   r = getavail () ; 
  477.   mem [ q ] .hh .v.RH = r ; 
  478.   mem [ r ] .hh .v.LH = 7362 ; 
  479.   begintokenlist ( q , 4 ) ; 
  480.   begintokenlist ( mem [ p + 1 ] .hh .v.RH , 15 ) ; 
  481.   q = getavail () ; 
  482.   mem [ q ] .hh .v.LH = 379 ; 
  483.   begintokenlist ( q , 4 ) ; 
  484.   oldmode = curlist .modefield ; 
  485.   curlist .modefield = 0 ; 
  486.   curcs = writeloc ; 
  487.   q = scantoks ( false , true ) ; 
  488.   gettoken () ; 
  489.   if ( curtok != 7362 ) 
  490.   {
  491.     {
  492.       if ( interaction == 3 ) 
  493.       wakeupterminal () ; 
  494.       printnl ( 133 ) ; 
  495.       print ( 1139 ) ; 
  496.     } 
  497.     {
  498.       helpptr = 2 ; 
  499.       helpline [ 1 ] = 1140 ; 
  500.       helpline [ 0 ] = 860 ; 
  501.     } 
  502.     error () ; 
  503.     do {
  504.     gettoken () ; 
  505.     } while ( ! ( curtok == 7362 ) ) ; 
  506.   } 
  507.   curlist .modefield = oldmode ; 
  508.   endtokenlist () ; 
  509.   oldsetting = selector ; 
  510.   j = mem [ p + 1 ] .hh .v.LH ; 
  511.   if ( writeopen [ j ] ) 
  512.   selector = j ; 
  513.   else {
  514.       
  515.     if ( ( j == 17 ) && ( selector == 19 ) ) 
  516.     selector = 18 ; 
  517.     printnl ( 206 ) ; 
  518.   } 
  519.   showtokenlist ( mem [ defref ] .hh .v.RH , 0 , 10000000L ) ; 
  520.   println () ; 
  521.   flushlist ( defref ) ; 
  522.   selector = oldsetting ; 
  523. } 
  524. zoutwhat ( p ) 
  525. halfword p ; 
  526. {outwhat_regmem 
  527.   smallnumber j  ; 
  528.   switch ( mem [ p ] .hh.b1 ) 
  529.   {case 0 : 
  530.   case 1 : 
  531.   case 2 : 
  532.     if ( ! doingleaders ) 
  533.     {
  534.       j = mem [ p + 1 ] .hh .v.LH ; 
  535.       if ( mem [ p ] .hh.b1 == 1 ) 
  536.       writeout ( p ) ; 
  537.       else {
  538.       
  539.     if ( writeopen [ j ] ) 
  540.     aclose ( writefile [ j ] ) ; 
  541.     if ( mem [ p ] .hh.b1 == 2 ) 
  542.     writeopen [ j ] = false ; 
  543.     else if ( j < 16 ) 
  544.     {
  545.       curname = mem [ p + 1 ] .hh .v.RH ; 
  546.       curarea = mem [ p + 2 ] .hh .v.LH ; 
  547.       curext = mem [ p + 2 ] .hh .v.RH ; 
  548.       if ( curext == 206 ) 
  549.       curext = 644 ; 
  550.       packfilename ( curname , curarea , curext ) ; 
  551.       while ( ! aopenout ( writefile [ j ] ) ) promptfilename ( 1142 , 644 
  552.       ) ; 
  553.       writeopen [ j ] = true ; 
  554.     } 
  555.       } 
  556.     } 
  557.     break ; 
  558.   case 3 : 
  559.     specialout ( p ) ; 
  560.     break ; 
  561.     default: 
  562.     confusion ( 1141 ) ; 
  563.     break ; 
  564.   } 
  565. } 
  566. hlistout () {
  567.     /* 21 13 14 15 */ hlistout_regmem 
  568.   scaled baseline  ; 
  569.   scaled leftedge  ; 
  570.   scaled saveh, savev  ; 
  571.   halfword thisbox  ; 
  572.   glueord gorder  ; 
  573.   schar gsign  ; 
  574.   halfword p  ; 
  575.   integer saveloc  ; 
  576.   halfword leaderbox  ; 
  577.   scaled leaderwd  ; 
  578.   scaled lx  ; 
  579.   boolean outerdoingleaders  ; 
  580.   scaled edge  ; 
  581.   thisbox = tempptr ; 
  582.   gorder = mem [ thisbox + 5 ] .hh.b1 ; 
  583.   gsign = mem [ thisbox + 5 ] .hh.b0 ; 
  584.   p = mem [ thisbox + 5 ] .hh .v.RH ; 
  585.   incr ( curs ) ; 
  586.   if ( curs > 0 ) 
  587.   {
  588.     dvibuf [ dviptr ] = 141 ; 
  589.     incr ( dviptr ) ; 
  590.     if ( dviptr == dvilimit ) 
  591.     dviswap () ; 
  592.   } 
  593.   if ( curs > maxpush ) 
  594.   maxpush = curs ; 
  595.   saveloc = dvioffset + dviptr ; 
  596.   baseline = curv ; 
  597.   leftedge = curh ; 
  598.   while ( p != 0 ) lab21: if ( ( p >= himemmin ) ) 
  599.   {
  600.     if ( curh != dvih ) 
  601.     {
  602.       movement ( curh - dvih , 143 ) ; 
  603.       dvih = curh ; 
  604.     } 
  605.     if ( curv != dviv ) 
  606.     {
  607.       movement ( curv - dviv , 157 ) ; 
  608.       dviv = curv ; 
  609.     } 
  610.     do {
  611.     f = mem [ p ] .hh.b0 ; 
  612.       c = mem [ p ] .hh.b1 ; 
  613.       if ( f != dvif ) 
  614.       {
  615.     if ( ! fontused [ f ] ) 
  616.     {
  617.       dvifontdef ( f ) ; 
  618.       fontused [ f ] = true ; 
  619.     } 
  620.     if ( f <= 64 ) 
  621.     {
  622.       dvibuf [ dviptr ] = f + 170 ; 
  623.       incr ( dviptr ) ; 
  624.       if ( dviptr == dvilimit ) 
  625.       dviswap () ; 
  626.     } 
  627.     else {
  628.         
  629.       {
  630.         dvibuf [ dviptr ] = 235 ; 
  631.         incr ( dviptr ) ; 
  632.         if ( dviptr == dvilimit ) 
  633.         dviswap () ; 
  634.       } 
  635.       {
  636.         dvibuf [ dviptr ] = f - 1 ; 
  637.         incr ( dviptr ) ; 
  638.         if ( dviptr == dvilimit ) 
  639.         dviswap () ; 
  640.       } 
  641.     } 
  642.     dvif = f ; 
  643.       } 
  644.       if ( c >= 128 ) 
  645.       {
  646.     dvibuf [ dviptr ] = 128 ; 
  647.     incr ( dviptr ) ; 
  648.     if ( dviptr == dvilimit ) 
  649.     dviswap () ; 
  650.       } 
  651.       {
  652.     dvibuf [ dviptr ] = c ; 
  653.     incr ( dviptr ) ; 
  654.     if ( dviptr == dvilimit ) 
  655.     dviswap () ; 
  656.       } 
  657.       curh = curh + fontinfo [ widthbase [ f ] + fontinfo [ charbase [ f ] + c 
  658.       ] .qqqq .b0 ] .cint ; 
  659.       p = mem [ p ] .hh .v.RH ; 
  660.     } while ( ! ( ! ( p >= himemmin ) ) ) ; 
  661.     dvih = curh ; 
  662.   } 
  663.   else {
  664.       
  665.     switch ( mem [ p ] .hh.b0 ) 
  666.     {case 0 : 
  667.     case 1 : 
  668.       if ( mem [ p + 5 ] .hh .v.RH == 0 ) 
  669.       curh = curh + mem [ p + 1 ] .cint ; 
  670.       else {
  671.       
  672.     saveh = dvih ; 
  673.     savev = dviv ; 
  674.     curv = baseline + mem [ p + 4 ] .cint ; 
  675.     tempptr = p ; 
  676.     edge = curh ; 
  677.     if ( mem [ p ] .hh.b0 == 1 ) 
  678.     vlistout () ; 
  679.     else hlistout () ; 
  680.     dvih = saveh ; 
  681.     dviv = savev ; 
  682.     curh = edge + mem [ p + 1 ] .cint ; 
  683.     curv = baseline ; 
  684.       } 
  685.       break ; 
  686.     case 2 : 
  687.       {
  688.     ruleht = mem [ p + 3 ] .cint ; 
  689.     ruledp = mem [ p + 2 ] .cint ; 
  690.     rulewd = mem [ p + 1 ] .cint ; 
  691.     goto lab14 ; 
  692.       } 
  693.       break ; 
  694.     case 8 : 
  695.       outwhat ( p ) ; 
  696.       break ; 
  697.     case 10 : 
  698.       {
  699.     g = mem [ p + 1 ] .hh .v.LH ; 
  700.     rulewd = mem [ g + 1 ] .cint ; 
  701.     if ( gsign != 0 ) 
  702.     {
  703.       if ( gsign == 1 ) 
  704.       {
  705.         if ( mem [ g ] .hh.b0 == gorder ) 
  706.         rulewd = rulewd + round ( mem [ thisbox + 6 ] .gr * mem [ g + 2 ] 
  707.         .cint ) ; 
  708.       } 
  709.       else {
  710.           
  711.         if ( mem [ g ] .hh.b1 == gorder ) 
  712.         rulewd = rulewd - round ( mem [ thisbox + 6 ] .gr * mem [ g + 3 ] 
  713.         .cint ) ; 
  714.       } 
  715.     } 
  716.     if ( mem [ p ] .hh.b1 >= 100 ) 
  717.     {
  718.       leaderbox = mem [ p + 1 ] .hh .v.RH ; 
  719.       if ( mem [ leaderbox ] .hh.b0 == 2 ) 
  720.       {
  721.         ruleht = mem [ leaderbox + 3 ] .cint ; 
  722.         ruledp = mem [ leaderbox + 2 ] .cint ; 
  723.         goto lab14 ; 
  724.       } 
  725.       leaderwd = mem [ leaderbox + 1 ] .cint ; 
  726.       if ( ( leaderwd > 0 ) && ( rulewd > 0 ) ) 
  727.       {
  728.         rulewd = rulewd + 10 ; 
  729.         edge = curh + rulewd ; 
  730.         lx = 0 ; 
  731.         if ( mem [ p ] .hh.b1 == 100 ) 
  732.         {
  733.           saveh = curh ; 
  734.           curh = leftedge + leaderwd * ( ( curh - leftedge ) / leaderwd ) 
  735.           ; 
  736.           if ( curh < saveh ) 
  737.           curh = curh + leaderwd ; 
  738.         } 
  739.         else {
  740.         
  741.           lq = rulewd / leaderwd ; 
  742.           lr = rulewd % leaderwd ; 
  743.           if ( mem [ p ] .hh.b1 == 101 ) 
  744.           curh = curh + ( lr / 2 ) ; 
  745.           else {
  746.           
  747.         lx = ( 2 * lr + lq + 1 ) / ( 2 * lq + 2 ) ; 
  748.         curh = curh + ( ( lr - ( lq - 1 ) * lx ) / 2 ) ; 
  749.           } 
  750.         } 
  751.         while ( curh + leaderwd <= edge ) {
  752.         
  753.           curv = baseline + mem [ leaderbox + 4 ] .cint ; 
  754.           if ( curv != dviv ) 
  755.           {
  756.         movement ( curv - dviv , 157 ) ; 
  757.         dviv = curv ; 
  758.           } 
  759.           savev = dviv ; 
  760.           if ( curh != dvih ) 
  761.           {
  762.         movement ( curh - dvih , 143 ) ; 
  763.         dvih = curh ; 
  764.           } 
  765.           saveh = dvih ; 
  766.           tempptr = leaderbox ; 
  767.           outerdoingleaders = doingleaders ; 
  768.           doingleaders = true ; 
  769.           if ( mem [ leaderbox ] .hh.b0 == 1 ) 
  770.           vlistout () ; 
  771.           else hlistout () ; 
  772.           doingleaders = outerdoingleaders ; 
  773.           dviv = savev ; 
  774.           dvih = saveh ; 
  775.           curv = savev ; 
  776.           curh = saveh + leaderwd + lx ; 
  777.         } 
  778.         curh = edge - 10 ; 
  779.         goto lab15 ; 
  780.       } 
  781.     } 
  782.     goto lab13 ; 
  783.       } 
  784.       break ; 
  785.     case 11 : 
  786.     case 9 : 
  787.       curh = curh + mem [ p + 1 ] .cint ; 
  788.       break ; 
  789.     case 6 : 
  790.       {
  791.     mem [ memtop - 12 ] = mem [ p + 1 ] ; 
  792.     mem [ memtop - 12 ] .hh .v.RH = mem [ p ] .hh .v.RH ; 
  793.     p = memtop - 12 ; 
  794.     goto lab21 ; 
  795.       } 
  796.       break ; 
  797.       default: 
  798.       ; 
  799.       break ; 
  800.     } 
  801.     goto lab15 ; 
  802.     lab14: if ( ( ruleht == -1073741824L ) ) 
  803.     ruleht = mem [ thisbox + 3 ] .cint ; 
  804.     if ( ( ruledp == -1073741824L ) ) 
  805.     ruledp = mem [ thisbox + 2 ] .cint ; 
  806.     ruleht = ruleht + ruledp ; 
  807.     if ( ( ruleht > 0 ) && ( rulewd > 0 ) ) 
  808.     {
  809.       if ( curh != dvih ) 
  810.       {
  811.     movement ( curh - dvih , 143 ) ; 
  812.     dvih = curh ; 
  813.       } 
  814.       curv = baseline + ruledp ; 
  815.       if ( curv != dviv ) 
  816.       {
  817.     movement ( curv - dviv , 157 ) ; 
  818.     dviv = curv ; 
  819.       } 
  820.       {
  821.     dvibuf [ dviptr ] = 132 ; 
  822.     incr ( dviptr ) ; 
  823.     if ( dviptr == dvilimit ) 
  824.     dviswap () ; 
  825.       } 
  826.       dvifour ( ruleht ) ; 
  827.       dvifour ( rulewd ) ; 
  828.       curv = baseline ; 
  829.       dvih = dvih + rulewd ; 
  830.     } 
  831.     lab13: curh = curh + rulewd ; 
  832.     lab15: p = mem [ p ] .hh .v.RH ; 
  833.   } 
  834.   prunemovements ( saveloc ) ; 
  835.   if ( curs > 0 ) 
  836.   dvipop ( saveloc ) ; 
  837.   decr ( curs ) ; 
  838. } 
  839. vlistout () {
  840.     /* 13 14 15 */ vlistout_regmem 
  841.   scaled leftedge  ; 
  842.   scaled topedge  ; 
  843.   scaled saveh, savev  ; 
  844.   halfword thisbox  ; 
  845.   glueord gorder  ; 
  846.   schar gsign  ; 
  847.   halfword p  ; 
  848.   integer saveloc  ; 
  849.   halfword leaderbox  ; 
  850.   scaled leaderht  ; 
  851.   scaled lx  ; 
  852.   boolean outerdoingleaders  ; 
  853.   scaled edge  ; 
  854.   thisbox = tempptr ; 
  855.   gorder = mem [ thisbox + 5 ] .hh.b1 ; 
  856.   gsign = mem [ thisbox + 5 ] .hh.b0 ; 
  857.   p = mem [ thisbox + 5 ] .hh .v.RH ; 
  858.   incr ( curs ) ; 
  859.   if ( curs > 0 ) 
  860.   {
  861.     dvibuf [ dviptr ] = 141 ; 
  862.     incr ( dviptr ) ; 
  863.     if ( dviptr == dvilimit ) 
  864.     dviswap () ; 
  865.   } 
  866.   if ( curs > maxpush ) 
  867.   maxpush = curs ; 
  868.   saveloc = dvioffset + dviptr ; 
  869.   leftedge = curh ; 
  870.   curv = curv - mem [ thisbox + 3 ] .cint ; 
  871.   topedge = curv ; 
  872.   while ( p != 0 ) {
  873.       
  874.     if ( ( p >= himemmin ) ) 
  875.     confusion ( 681 ) ; 
  876.     else {
  877.     
  878.       switch ( mem [ p ] .hh.b0 ) 
  879.       {case 0 : 
  880.       case 1 : 
  881.     if ( mem [ p + 5 ] .hh .v.RH == 0 ) 
  882.     curv = curv + mem [ p + 3 ] .cint + mem [ p + 2 ] .cint ; 
  883.     else {
  884.         
  885.       curv = curv + mem [ p + 3 ] .cint ; 
  886.       if ( curv != dviv ) 
  887.       {
  888.         movement ( curv - dviv , 157 ) ; 
  889.         dviv = curv ; 
  890.       } 
  891.       saveh = dvih ; 
  892.       savev = dviv ; 
  893.       curh = leftedge + mem [ p + 4 ] .cint ; 
  894.       tempptr = p ; 
  895.       if ( mem [ p ] .hh.b0 == 1 ) 
  896.       vlistout () ; 
  897.       else hlistout () ; 
  898.       dvih = saveh ; 
  899.       dviv = savev ; 
  900.       curv = savev + mem [ p + 2 ] .cint ; 
  901.       curh = leftedge ; 
  902.     } 
  903.     break ; 
  904.       case 2 : 
  905.     {
  906.       ruleht = mem [ p + 3 ] .cint ; 
  907.       ruledp = mem [ p + 2 ] .cint ; 
  908.       rulewd = mem [ p + 1 ] .cint ; 
  909.       goto lab14 ; 
  910.     } 
  911.     break ; 
  912.       case 8 : 
  913.     outwhat ( p ) ; 
  914.     break ; 
  915.       case 10 : 
  916.     {
  917.       g = mem [ p + 1 ] .hh .v.LH ; 
  918.       ruleht = mem [ g + 1 ] .cint ; 
  919.       if ( gsign != 0 ) 
  920.       {
  921.         if ( gsign == 1 ) 
  922.         {
  923.           if ( mem [ g ] .hh.b0 == gorder ) 
  924.           ruleht = ruleht + round ( mem [ thisbox + 6 ] .gr * mem [ g + 2 
  925.           ] .cint ) ; 
  926.         } 
  927.         else {
  928.         
  929.           if ( mem [ g ] .hh.b1 == gorder ) 
  930.           ruleht = ruleht - round ( mem [ thisbox + 6 ] .gr * mem [ g + 3 
  931.           ] .cint ) ; 
  932.         } 
  933.       } 
  934.       if ( mem [ p ] .hh.b1 >= 100 ) 
  935.       {
  936.         leaderbox = mem [ p + 1 ] .hh .v.RH ; 
  937.         if ( mem [ leaderbox ] .hh.b0 == 2 ) 
  938.         {
  939.           rulewd = mem [ leaderbox + 1 ] .cint ; 
  940.           ruledp = 0 ; 
  941.           goto lab14 ; 
  942.         } 
  943.         leaderht = mem [ leaderbox + 3 ] .cint + mem [ leaderbox + 2 ] 
  944.         .cint ; 
  945.         if ( ( leaderht > 0 ) && ( ruleht > 0 ) ) 
  946.         {
  947.           ruleht = ruleht + 10 ; 
  948.           edge = curv + ruleht ; 
  949.           lx = 0 ; 
  950.           if ( mem [ p ] .hh.b1 == 100 ) 
  951.           {
  952.         savev = curv ; 
  953.         curv = topedge + leaderht * ( ( curv - topedge ) / leaderht ) 
  954.         ; 
  955.         if ( curv < savev ) 
  956.         curv = curv + leaderht ; 
  957.           } 
  958.           else {
  959.           
  960.         lq = ruleht / leaderht ; 
  961.         lr = ruleht % leaderht ; 
  962.         if ( mem [ p ] .hh.b1 == 101 ) 
  963.         curv = curv + ( lr / 2 ) ; 
  964.         else {
  965.             
  966.           lx = ( 2 * lr + lq + 1 ) / ( 2 * lq + 2 ) ; 
  967.           curv = curv + ( ( lr - ( lq - 1 ) * lx ) / 2 ) ; 
  968.         } 
  969.           } 
  970.           while ( curv + leaderht <= edge ) {
  971.           
  972.         curh = leftedge + mem [ leaderbox + 4 ] .cint ; 
  973.         if ( curh != dvih ) 
  974.         {
  975.           movement ( curh - dvih , 143 ) ; 
  976.           dvih = curh ; 
  977.         } 
  978.         saveh = dvih ; 
  979.         curv = curv + mem [ leaderbox + 3 ] .cint ; 
  980.         if ( curv != dviv ) 
  981.         {
  982.           movement ( curv - dviv , 157 ) ; 
  983.           dviv = curv ; 
  984.         } 
  985.         savev = dviv ; 
  986.         tempptr = leaderbox ; 
  987.         outerdoingleaders = doingleaders ; 
  988.         doingleaders = true ; 
  989.         if ( mem [ leaderbox ] .hh.b0 == 1 ) 
  990.         vlistout () ; 
  991.         else hlistout () ; 
  992.         doingleaders = outerdoingleaders ; 
  993.         dviv = savev ; 
  994.         dvih = saveh ; 
  995.         curh = saveh ; 
  996.         curv = savev - mem [ leaderbox + 3 ] .cint + leaderht + lx ; 
  997.           } 
  998.           curv = edge - 10 ; 
  999.           goto lab15 ; 
  1000.         } 
  1001.       } 
  1002.       goto lab13 ; 
  1003.     } 
  1004.     break ; 
  1005.       case 11 : 
  1006.     curv = curv + mem [ p + 1 ] .cint ; 
  1007.     break ; 
  1008.     default: 
  1009.     ; 
  1010.     break ; 
  1011.       } 
  1012.       goto lab15 ; 
  1013.       lab14: if ( ( rulewd == -1073741824L ) ) 
  1014.       rulewd = mem [ thisbox + 1 ] .cint ; 
  1015.       ruleht = ruleht + ruledp ; 
  1016.       curv = curv + ruleht ; 
  1017.       if ( ( ruleht > 0 ) && ( rulewd > 0 ) ) 
  1018.       {
  1019.     if ( curh != dvih ) 
  1020.     {
  1021.       movement ( curh - dvih , 143 ) ; 
  1022.       dvih = curh ; 
  1023.     } 
  1024.     if ( curv != dviv ) 
  1025.     {
  1026.       movement ( curv - dviv , 157 ) ; 
  1027.       dviv = curv ; 
  1028.     } 
  1029.     {
  1030.       dvibuf [ dviptr ] = 137 ; 
  1031.       incr ( dviptr ) ; 
  1032.       if ( dviptr == dvilimit ) 
  1033.       dviswap () ; 
  1034.     } 
  1035.     dvifour ( ruleht ) ; 
  1036.     dvifour ( rulewd ) ; 
  1037.       } 
  1038.       goto lab15 ; 
  1039.       lab13: curv = curv + ruleht ; 
  1040.     } 
  1041.     lab15: p = mem [ p ] .hh .v.RH ; 
  1042.   } 
  1043.   prunemovements ( saveloc ) ; 
  1044.   if ( curs > 0 ) 
  1045.   dvipop ( saveloc ) ; 
  1046.   decr ( curs ) ; 
  1047. } 
  1048. zshipout ( p ) 
  1049. halfword p ; 
  1050. {/* 30 */ shipout_regmem 
  1051.   integer pageloc  ; 
  1052.   schar j, k  ; 
  1053.   poolpointer s  ; 
  1054.   schar oldsetting  ; 
  1055.   if ( eqtb [ 5301 ] .cint > 0 ) 
  1056.   {
  1057.     printnl ( 206 ) ; 
  1058.     println () ; 
  1059.     print ( 682 ) ; 
  1060.   } 
  1061.   if ( termoffset > maxprintline - 9 ) 
  1062.   println () ; 
  1063.   else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) ) 
  1064.   printchar ( 32 ) ; 
  1065.   printchar ( 91 ) ; 
  1066.   j = 9 ; 
  1067.   while ( ( eqtb [ 5317 + j ] .cint == 0 ) && ( j > 0 ) ) decr ( j ) ; 
  1068.   {register integer for_end; k = 0 ; for_end = j ; if ( k <= for_end) do 
  1069.     {
  1070.       printint ( eqtb [ 5317 + k ] .cint ) ; 
  1071.       if ( k < j ) 
  1072.       printchar ( 46 ) ; 
  1073.     } 
  1074.   while ( k++ < for_end ) ; } 
  1075.   termflush ( stdout ) ; 
  1076.   if ( eqtb [ 5301 ] .cint > 0 ) 
  1077.   {
  1078.     printchar ( 93 ) ; 
  1079.     begindiagnostic () ; 
  1080.     showbox ( p ) ; 
  1081.     enddiagnostic ( true ) ; 
  1082.   } 
  1083.   if ( ( mem [ p + 3 ] .cint > 1073741823L ) || ( mem [ p + 2 ] .cint > 
  1084.   1073741823L ) || ( mem [ p + 3 ] .cint + mem [ p + 2 ] .cint + eqtb [ 5720 ] 
  1085.   .cint > 1073741823L ) || ( mem [ p + 1 ] .cint + eqtb [ 5719 ] .cint > 
  1086.   1073741823L ) ) 
  1087.   {
  1088.     {
  1089.       if ( interaction == 3 ) 
  1090.       wakeupterminal () ; 
  1091.       printnl ( 133 ) ; 
  1092.       print ( 686 ) ; 
  1093.     } 
  1094.     {
  1095.       helpptr = 2 ; 
  1096.       helpline [ 1 ] = 687 ; 
  1097.       helpline [ 0 ] = 688 ; 
  1098.     } 
  1099.     error () ; 
  1100.     if ( eqtb [ 5301 ] .cint <= 0 ) 
  1101.     {
  1102.       begindiagnostic () ; 
  1103.       printnl ( 689 ) ; 
  1104.       showbox ( p ) ; 
  1105.       enddiagnostic ( true ) ; 
  1106.     } 
  1107.     goto lab30 ; 
  1108.   } 
  1109.   if ( mem [ p + 3 ] .cint + mem [ p + 2 ] .cint + eqtb [ 5720 ] .cint > maxv 
  1110.   ) 
  1111.   maxv = mem [ p + 3 ] .cint + mem [ p + 2 ] .cint + eqtb [ 5720 ] .cint ; 
  1112.   if ( mem [ p + 1 ] .cint + eqtb [ 5719 ] .cint > maxh ) 
  1113.   maxh = mem [ p + 1 ] .cint + eqtb [ 5719 ] .cint ; 
  1114.   dvih = 0 ; 
  1115.   dviv = 0 ; 
  1116.   curh = eqtb [ 5719 ] .cint ; 
  1117.   dvif = 0 ; 
  1118.   if ( outputfilename == 0 ) 
  1119.   {
  1120.     if ( jobname == 0 ) 
  1121.     openlogfile () ; 
  1122.     packjobname ( 647 ) ; 
  1123.     while ( ! bopenout ( dvifile ) ) promptfilename ( 648 , 647 ) ; 
  1124.     outputfilename = bmakenamestring ( dvifile ) ; 
  1125.   } 
  1126.   if ( totalpages == 0 ) 
  1127.   {
  1128.     {
  1129.       dvibuf [ dviptr ] = 247 ; 
  1130.       incr ( dviptr ) ; 
  1131.       if ( dviptr == dvilimit ) 
  1132.       dviswap () ; 
  1133.     } 
  1134.     {
  1135.       dvibuf [ dviptr ] = 2 ; 
  1136.       incr ( dviptr ) ; 
  1137.       if ( dviptr == dvilimit ) 
  1138.       dviswap () ; 
  1139.     } 
  1140.     dvifour ( 25400000L ) ; 
  1141.     dvifour ( 473628672L ) ; 
  1142.     preparemag () ; 
  1143.     dvifour ( eqtb [ 5284 ] .cint ) ; 
  1144.     oldsetting = selector ; 
  1145.     selector = 21 ; 
  1146.     print ( 680 ) ; 
  1147.     printint ( eqtb [ 5290 ] .cint ) ; 
  1148.     printchar ( 46 ) ; 
  1149.     printtwo ( eqtb [ 5289 ] .cint ) ; 
  1150.     printchar ( 46 ) ; 
  1151.     printtwo ( eqtb [ 5288 ] .cint ) ; 
  1152.     printchar ( 58 ) ; 
  1153.     printtwo ( eqtb [ 5287 ] .cint / 60 ) ; 
  1154.     printtwo ( eqtb [ 5287 ] .cint % 60 ) ; 
  1155.     selector = oldsetting ; 
  1156.     {
  1157.       dvibuf [ dviptr ] = ( poolptr - strstart [ strptr ] ) ; 
  1158.       incr ( dviptr ) ; 
  1159.       if ( dviptr == dvilimit ) 
  1160.       dviswap () ; 
  1161.     } 
  1162.     {register integer for_end; s = strstart [ strptr ] ; for_end = poolptr - 
  1163.     1 ; if ( s <= for_end) do 
  1164.       {
  1165.     dvibuf [ dviptr ] = strpool [ s ] ; 
  1166.     incr ( dviptr ) ; 
  1167.     if ( dviptr == dvilimit ) 
  1168.     dviswap () ; 
  1169.       } 
  1170.     while ( s++ < for_end ) ; } 
  1171.     poolptr = strstart [ strptr ] ; 
  1172.   } 
  1173.   pageloc = dvioffset + dviptr ; 
  1174.   {
  1175.     dvibuf [ dviptr ] = 139 ; 
  1176.     incr ( dviptr ) ; 
  1177.     if ( dviptr == dvilimit ) 
  1178.     dviswap () ; 
  1179.   } 
  1180.   {register integer for_end; k = 0 ; for_end = 9 ; if ( k <= for_end) do 
  1181.     dvifour ( eqtb [ 5317 + k ] .cint ) ; 
  1182.   while ( k++ < for_end ) ; } 
  1183.   dvifour ( lastbop ) ; 
  1184.   lastbop = pageloc ; 
  1185.   curv = mem [ p + 3 ] .cint + eqtb [ 5720 ] .cint ; 
  1186.   tempptr = p ; 
  1187.   if ( mem [ p ] .hh.b0 == 1 ) 
  1188.   vlistout () ; 
  1189.   else hlistout () ; 
  1190.   {
  1191.     dvibuf [ dviptr ] = 140 ; 
  1192.     incr ( dviptr ) ; 
  1193.     if ( dviptr == dvilimit ) 
  1194.     dviswap () ; 
  1195.   } 
  1196.   incr ( totalpages ) ; 
  1197.   curs = -1 ; 
  1198.   lab30: ; 
  1199.   if ( eqtb [ 5301 ] .cint <= 0 ) 
  1200.   printchar ( 93 ) ; 
  1201.   deadcycles = 0 ; 
  1202.   termflush ( stdout ) ; 
  1203.     ;
  1204. #ifdef STAT
  1205.   if ( eqtb [ 5298 ] .cint > 1 ) 
  1206.   {
  1207.     printnl ( 683 ) ; 
  1208.     printint ( varused ) ; 
  1209.     printchar ( 38 ) ; 
  1210.     printint ( dynused ) ; 
  1211.     printchar ( 59 ) ; 
  1212.   } 
  1213. #endif /* STAT */
  1214.   flushnodelist ( p ) ; 
  1215.     ;
  1216. #ifdef STAT
  1217.   if ( eqtb [ 5298 ] .cint > 1 ) 
  1218.   {
  1219.     print ( 684 ) ; 
  1220.     printint ( varused ) ; 
  1221.     printchar ( 38 ) ; 
  1222.     printint ( dynused ) ; 
  1223.     print ( 685 ) ; 
  1224.     printint ( himemmin - lomemmax - 1 ) ; 
  1225.     println () ; 
  1226.   } 
  1227. #endif /* STAT */
  1228. } 
  1229. scanspec () {
  1230.     /* 40 */ scanspec_regmem 
  1231.   if ( scankeyword ( 695 ) ) 
  1232.   savestack [ saveptr + 0 ] .cint = 0 ; 
  1233.   else if ( scankeyword ( 696 ) ) 
  1234.   savestack [ saveptr + 0 ] .cint = 1 ; 
  1235.   else {
  1236.       
  1237.     savestack [ saveptr + 0 ] .cint = 1 ; 
  1238.     savestack [ saveptr + 1 ] .cint = 0 ; 
  1239.     goto lab40 ; 
  1240.   } 
  1241.   scandimen ( false , false , false ) ; 
  1242.   savestack [ saveptr + 1 ] .cint = curval ; 
  1243.   lab40: saveptr = saveptr + 2 ; 
  1244.   scanleftbrace () ; 
  1245. } 
  1246. halfword zhpack ( p , w , m ) 
  1247. halfword p ; 
  1248. scaled w ; 
  1249. smallnumber m ; 
  1250. {/* 21 50 10 */ register halfword Result; hpack_regmem 
  1251.   halfword r  ; 
  1252.   halfword q  ; 
  1253.   scaled h, d, x  ; 
  1254.   scaled s  ; 
  1255.   halfword g  ; 
  1256.   glueord o  ; 
  1257.   internalfontnumber f  ; 
  1258.   fourquarters i  ; 
  1259.   eightbits hd  ; 
  1260.   integer b  ; 
  1261.   r = getnode ( 7 ) ; 
  1262.   mem [ r ] .hh.b0 = 0 ; 
  1263.   mem [ r ] .hh.b1 = 0 ; 
  1264.   mem [ r + 4 ] .cint = 0 ; 
  1265.   q = r + 5 ; 
  1266.   mem [ q ] .hh .v.RH = p ; 
  1267.   h = 0 ; 
  1268.   d = 0 ; 
  1269.   x = 0 ; 
  1270.   totalstretch [ 0 ] = 0 ; 
  1271.   totalshrink [ 0 ] = 0 ; 
  1272.   totalstretch [ 1 ] = 0 ; 
  1273.   totalshrink [ 1 ] = 0 ; 
  1274.   totalstretch [ 2 ] = 0 ; 
  1275.   totalshrink [ 2 ] = 0 ; 
  1276.   totalstretch [ 3 ] = 0 ; 
  1277.   totalshrink [ 3 ] = 0 ; 
  1278.   while ( p != 0 ) {
  1279.       
  1280.     lab21: while ( ( p >= himemmin ) ) {
  1281.     
  1282.       f = mem [ p ] .hh.b0 ; 
  1283.       i = fontinfo [ charbase [ f ] + mem [ p ] .hh.b1 ] .qqqq ; 
  1284.       hd = i .b1 ; 
  1285.       x = x + fontinfo [ widthbase [ f ] + i .b0 ] .cint ; 
  1286.       s = fontinfo [ heightbase [ f ] + ( hd ) / 16 ] .cint ; 
  1287.       if ( s > h ) 
  1288.       h = s ; 
  1289.       s = fontinfo [ depthbase [ f ] + ( hd ) % 16 ] .cint ; 
  1290.       if ( s > d ) 
  1291.       d = s ; 
  1292.       p = mem [ p ] .hh .v.RH ; 
  1293.     } 
  1294.     if ( p != 0 ) 
  1295.     {
  1296.       switch ( mem [ p ] .hh.b0 ) 
  1297.       {case 0 : 
  1298.       case 1 : 
  1299.       case 2 : 
  1300.       case 13 : 
  1301.     {
  1302.       x = x + mem [ p + 1 ] .cint ; 
  1303.       if ( mem [ p ] .hh.b0 >= 2 ) 
  1304.       s = 0 ; 
  1305.       else s = mem [ p + 4 ] .cint ; 
  1306.       if ( mem [ p + 3 ] .cint - s > h ) 
  1307.       h = mem [ p + 3 ] .cint - s ; 
  1308.       if ( mem [ p + 2 ] .cint + s > d ) 
  1309.       d = mem [ p + 2 ] .cint + s ; 
  1310.     } 
  1311.     break ; 
  1312.       case 3 : 
  1313.       case 4 : 
  1314.       case 5 : 
  1315.     if ( adjusttail != 0 ) 
  1316.     {
  1317.       while ( mem [ q ] .hh .v.RH != p ) q = mem [ q ] .hh .v.RH ; 
  1318.       if ( mem [ p ] .hh.b0 == 5 ) 
  1319.       {
  1320.         mem [ adjusttail ] .hh .v.RH = mem [ p + 1 ] .cint ; 
  1321.         while ( mem [ adjusttail ] .hh .v.RH != 0 ) adjusttail = mem [ 
  1322.         adjusttail ] .hh .v.RH ; 
  1323.         p = mem [ p ] .hh .v.RH ; 
  1324.         freenode ( mem [ q ] .hh .v.RH , 2 ) ; 
  1325.       } 
  1326.       else {
  1327.           
  1328.         mem [ adjusttail ] .hh .v.RH = p ; 
  1329.         adjusttail = p ; 
  1330.         p = mem [ p ] .hh .v.RH ; 
  1331.       } 
  1332.       mem [ q ] .hh .v.RH = p ; 
  1333.       p = q ; 
  1334.     } 
  1335.     break ; 
  1336.       case 8 : 
  1337.     ; 
  1338.     break ; 
  1339.       case 10 : 
  1340.     {
  1341.       g = mem [ p + 1 ] .hh .v.LH ; 
  1342.       x = x + mem [ g + 1 ] .cint ; 
  1343.       o = mem [ g ] .hh.b0 ; 
  1344.       totalstretch [ o ] = totalstretch [ o ] + mem [ g + 2 ] .cint ; 
  1345.       o = mem [ g ] .hh.b1 ; 
  1346.       totalshrink [ o ] = totalshrink [ o ] + mem [ g + 3 ] .cint ; 
  1347.       if ( mem [ p ] .hh.b1 >= 100 ) 
  1348.       {
  1349.         g = mem [ p + 1 ] .hh .v.RH ; 
  1350.         if ( mem [ g + 3 ] .cint > h ) 
  1351.         h = mem [ g + 3 ] .cint ; 
  1352.         if ( mem [ g + 2 ] .cint > d ) 
  1353.         d = mem [ g + 2 ] .cint ; 
  1354.       } 
  1355.     } 
  1356.     break ; 
  1357.       case 11 : 
  1358.       case 9 : 
  1359.     x = x + mem [ p + 1 ] .cint ; 
  1360.     break ; 
  1361.       case 6 : 
  1362.     {
  1363.       mem [ memtop - 12 ] = mem [ p + 1 ] ; 
  1364.       mem [ memtop - 12 ] .hh .v.RH = mem [ p ] .hh .v.RH ; 
  1365.       p = memtop - 12 ; 
  1366.       goto lab21 ; 
  1367.     } 
  1368.     break ; 
  1369.     default: 
  1370.     ; 
  1371.     break ; 
  1372.       } 
  1373.       p = mem [ p ] .hh .v.RH ; 
  1374.     } 
  1375.   } 
  1376.   if ( adjusttail != 0 ) 
  1377.   mem [ adjusttail ] .hh .v.RH = 0 ; 
  1378.   mem [ r + 3 ] .cint = h ; 
  1379.   mem [ r + 2 ] .cint = d ; 
  1380.   if ( m == 1 ) 
  1381.   w = x + w ; 
  1382.   mem [ r + 1 ] .cint = w ; 
  1383.   x = w - x ; 
  1384.   if ( x == 0 ) 
  1385.   {
  1386.     mem [ r + 5 ] .hh.b0 = 0 ; 
  1387.     mem [ r + 5 ] .hh.b1 = 0 ; 
  1388.     mem [ r + 6 ] .gr = 0.0 ; 
  1389.     goto lab10 ; 
  1390.   } 
  1391.   else if ( x > 0 ) 
  1392.   {
  1393.     if ( totalstretch [ 3 ] != 0 ) 
  1394.     o = 3 ; 
  1395.     else if ( totalstretch [ 2 ] != 0 ) 
  1396.     o = 2 ; 
  1397.     else if ( totalstretch [ 1 ] != 0 ) 
  1398.     o = 1 ; 
  1399.     else o = 0 ; 
  1400.     mem [ r + 5 ] .hh.b1 = o ; 
  1401.     mem [ r + 5 ] .hh.b0 = 1 ; 
  1402.     if ( totalstretch [ o ] != 0 ) 
  1403.     mem [ r + 6 ] .gr = x / ((double) totalstretch [ o ] ) ; 
  1404.     else {
  1405.     
  1406.       mem [ r + 5 ] .hh.b0 = 0 ; 
  1407.       mem [ r + 6 ] .gr = 0.0 ; 
  1408.     } 
  1409.     if ( ( eqtb [ 5293 ] .cint < 10000 ) && ( o == 0 ) && ( mem [ r + 5 ] .hh 
  1410.     .v.RH != 0 ) ) 
  1411.     {
  1412.       b = badness ( x , totalstretch [ 0 ] ) ; 
  1413.       if ( b > eqtb [ 5293 ] .cint ) 
  1414.       {
  1415.     println () ; 
  1416.     if ( b > 100 ) 
  1417.     printnl ( 697 ) ; 
  1418.     else printnl ( 698 ) ; 
  1419.     print ( 699 ) ; 
  1420.     printint ( b ) ; 
  1421.     goto lab50 ; 
  1422.       } 
  1423.     } 
  1424.     goto lab10 ; 
  1425.   } 
  1426.   else {
  1427.       
  1428.     if ( totalshrink [ 3 ] != 0 ) 
  1429.     o = 3 ; 
  1430.     else if ( totalshrink [ 2 ] != 0 ) 
  1431.     o = 2 ; 
  1432.     else if ( totalshrink [ 1 ] != 0 ) 
  1433.     o = 1 ; 
  1434.     else o = 0 ; 
  1435.     mem [ r + 5 ] .hh.b1 = o ; 
  1436.     mem [ r + 5 ] .hh.b0 = 2 ; 
  1437.     if ( totalshrink [ o ] != 0 ) 
  1438.     mem [ r + 6 ] .gr = ( - (integer) x ) / ((double) totalshrink [ o ] ) ; 
  1439.     else {
  1440.     
  1441.       mem [ r + 5 ] .hh.b0 = 0 ; 
  1442.       mem [ r + 6 ] .gr = 0.0 ; 
  1443.     } 
  1444.     if ( ( totalshrink [ o ] < - (integer) x ) && ( o == 0 ) && ( mem [ r + 5 
  1445.     ] .hh .v.RH != 0 ) ) 
  1446.     {
  1447.       mem [ r + 6 ] .gr = 1.0 ; 
  1448.       if ( ( - (integer) x - totalshrink [ 0 ] > eqtb [ 5709 ] .cint ) || ( 
  1449.       eqtb [ 5293 ] .cint < 100 ) ) 
  1450.       {
  1451.     if ( ( eqtb [ 5717 ] .cint > 0 ) && ( - (integer) x - totalshrink [ 0 
  1452.     ] > eqtb [ 5709 ] .cint ) ) 
  1453.     {
  1454.       while ( mem [ q ] .hh .v.RH != 0 ) q = mem [ q ] .hh .v.RH ; 
  1455.       mem [ q ] .hh .v.RH = newrule () ; 
  1456.       mem [ mem [ q ] .hh .v.RH + 1 ] .cint = eqtb [ 5717 ] .cint ; 
  1457.     } 
  1458.     println () ; 
  1459.     printnl ( 705 ) ; 
  1460.     printscaled ( - (integer) x - totalshrink [ 0 ] ) ; 
  1461.     print ( 706 ) ; 
  1462.     goto lab50 ; 
  1463.       } 
  1464.     } 
  1465.     else if ( ( eqtb [ 5293 ] .cint < 100 ) && ( o == 0 ) && ( mem [ r + 5 ] 
  1466.     .hh .v.RH != 0 ) ) 
  1467.     {
  1468.       b = badness ( - (integer) x , totalshrink [ 0 ] ) ; 
  1469.       if ( b > eqtb [ 5293 ] .cint ) 
  1470.       {
  1471.     println () ; 
  1472.     printnl ( 707 ) ; 
  1473.     printint ( b ) ; 
  1474.     goto lab50 ; 
  1475.       } 
  1476.     } 
  1477.     goto lab10 ; 
  1478.   } 
  1479.   lab50: if ( outputactive ) 
  1480.   print ( 700 ) ; 
  1481.   else {
  1482.       
  1483.     if ( packbeginline != 0 ) 
  1484.     {
  1485.       if ( packbeginline > 0 ) 
  1486.       print ( 701 ) ; 
  1487.       else print ( 702 ) ; 
  1488.       printint ( abs ( packbeginline ) ) ; 
  1489.       print ( 703 ) ; 
  1490.     } 
  1491.     else print ( 704 ) ; 
  1492.     printint ( line ) ; 
  1493.   } 
  1494.   println () ; 
  1495.   fontinshortdisplay = 0 ; 
  1496.   shortdisplay ( mem [ r + 5 ] .hh .v.RH ) ; 
  1497.   println () ; 
  1498.   begindiagnostic () ; 
  1499.   showbox ( r ) ; 
  1500.   enddiagnostic ( true ) ; 
  1501.   lab10: Result = r ; 
  1502.   return(Result) ; 
  1503. } 
  1504. halfword zvpackage ( p , h , m , l ) 
  1505. halfword p ; 
  1506. scaled h ; 
  1507. smallnumber m ; 
  1508. scaled l ; 
  1509. {/* 50 10 */ register halfword Result; vpackage_regmem 
  1510.   halfword r  ; 
  1511.   scaled w, d, x  ; 
  1512.   scaled s  ; 
  1513.   halfword g  ; 
  1514.   glueord o  ; 
  1515.   integer b  ; 
  1516.   r = getnode ( 7 ) ; 
  1517.   mem [ r ] .hh.b0 = 1 ; 
  1518.   mem [ r ] .hh.b1 = 0 ; 
  1519.   mem [ r + 4 ] .cint = 0 ; 
  1520.   mem [ r + 5 ] .hh .v.RH = p ; 
  1521.   w = 0 ; 
  1522.   d = 0 ; 
  1523.   x = 0 ; 
  1524.   totalstretch [ 0 ] = 0 ; 
  1525.   totalshrink [ 0 ] = 0 ; 
  1526.   totalstretch [ 1 ] = 0 ; 
  1527.   totalshrink [ 1 ] = 0 ; 
  1528.   totalstretch [ 2 ] = 0 ; 
  1529.   totalshrink [ 2 ] = 0 ; 
  1530.   totalstretch [ 3 ] = 0 ; 
  1531.   totalshrink [ 3 ] = 0 ; 
  1532.   while ( p != 0 ) {
  1533.       
  1534.     if ( ( p >= himemmin ) ) 
  1535.     confusion ( 708 ) ; 
  1536.     else switch ( mem [ p ] .hh.b0 ) 
  1537.     {case 0 : 
  1538.     case 1 : 
  1539.     case 2 : 
  1540.     case 13 : 
  1541.       {
  1542.     x = x + d + mem [ p + 3 ] .cint ; 
  1543.     d = mem [ p + 2 ] .cint ; 
  1544.     if ( mem [ p ] .hh.b0 >= 2 ) 
  1545.     s = 0 ; 
  1546.     else s = mem [ p + 4 ] .cint ; 
  1547.     if ( mem [ p + 1 ] .cint + s > w ) 
  1548.     w = mem [ p + 1 ] .cint + s ; 
  1549.       } 
  1550.       break ; 
  1551.     case 8 : 
  1552.       ; 
  1553.       break ; 
  1554.     case 10 : 
  1555.       {
  1556.     x = x + d ; 
  1557.     d = 0 ; 
  1558.     g = mem [ p + 1 ] .hh .v.LH ; 
  1559.     x = x + mem [ g + 1 ] .cint ; 
  1560.     o = mem [ g ] .hh.b0 ; 
  1561.     totalstretch [ o ] = totalstretch [ o ] + mem [ g + 2 ] .cint ; 
  1562.     o = mem [ g ] .hh.b1 ; 
  1563.     totalshrink [ o ] = totalshrink [ o ] + mem [ g + 3 ] .cint ; 
  1564.     if ( mem [ p ] .hh.b1 >= 100 ) 
  1565.     {
  1566.       g = mem [ p + 1 ] .hh .v.RH ; 
  1567.       if ( mem [ g + 1 ] .cint > w ) 
  1568.       w = mem [ g + 1 ] .cint ; 
  1569.     } 
  1570.       } 
  1571.       break ; 
  1572.     case 11 : 
  1573.       {
  1574.     x = x + d + mem [ p + 1 ] .cint ; 
  1575.     d = 0 ; 
  1576.       } 
  1577.       break ; 
  1578.       default: 
  1579.       ; 
  1580.       break ; 
  1581.     } 
  1582.     p = mem [ p ] .hh .v.RH ; 
  1583.   } 
  1584.   mem [ r + 1 ] .cint = w ; 
  1585.   if ( d > l ) 
  1586.   {
  1587.     x = x + d - l ; 
  1588.     mem [ r + 2 ] .cint = l ; 
  1589.   } 
  1590.   else mem [ r + 2 ] .cint = d ; 
  1591.   if ( m == 1 ) 
  1592.   h = x + h ; 
  1593.   mem [ r + 3 ] .cint = h ; 
  1594.   x = h - x ; 
  1595.   if ( x == 0 ) 
  1596.   {
  1597.     mem [ r + 5 ] .hh.b0 = 0 ; 
  1598.     mem [ r + 5 ] .hh.b1 = 0 ; 
  1599.     mem [ r + 6 ] .gr = 0.0 ; 
  1600.     goto lab10 ; 
  1601.   } 
  1602.   else if ( x > 0 ) 
  1603.   {
  1604.     if ( totalstretch [ 3 ] != 0 ) 
  1605.     o = 3 ; 
  1606.     else if ( totalstretch [ 2 ] != 0 ) 
  1607.     o = 2 ; 
  1608.     else if ( totalstretch [ 1 ] != 0 ) 
  1609.     o = 1 ; 
  1610.     else o = 0 ; 
  1611.     mem [ r + 5 ] .hh.b1 = o ; 
  1612.     mem [ r + 5 ] .hh.b0 = 1 ; 
  1613.     if ( totalstretch [ o ] != 0 ) 
  1614.     mem [ r + 6 ] .gr = x / ((double) totalstretch [ o ] ) ; 
  1615.     else {
  1616.     
  1617.       mem [ r + 5 ] .hh.b0 = 0 ; 
  1618.       mem [ r + 6 ] .gr = 0.0 ; 
  1619.     } 
  1620.     if ( ( eqtb [ 5294 ] .cint < 10000 ) && ( o == 0 ) && ( mem [ r + 5 ] .hh 
  1621.     .v.RH != 0 ) ) 
  1622.     {
  1623.       b = badness ( x , totalstretch [ 0 ] ) ; 
  1624.       if ( b > eqtb [ 5294 ] .cint ) 
  1625.       {
  1626.     println () ; 
  1627.     if ( b > 100 ) 
  1628.     printnl ( 697 ) ; 
  1629.     else printnl ( 698 ) ; 
  1630.     print ( 709 ) ; 
  1631.     printint ( b ) ; 
  1632.     goto lab50 ; 
  1633.       } 
  1634.     } 
  1635.     goto lab10 ; 
  1636.   } 
  1637.   else {
  1638.       
  1639.     if ( totalshrink [ 3 ] != 0 ) 
  1640.     o = 3 ; 
  1641.     else if ( totalshrink [ 2 ] != 0 ) 
  1642.     o = 2 ; 
  1643.     else if ( totalshrink [ 1 ] != 0 ) 
  1644.     o = 1 ; 
  1645.     else o = 0 ; 
  1646.     mem [ r + 5 ] .hh.b1 = o ; 
  1647.     mem [ r + 5 ] .hh.b0 = 2 ; 
  1648.     if ( totalshrink [ o ] != 0 ) 
  1649.     mem [ r + 6 ] .gr = ( - (integer) x ) / ((double) totalshrink [ o ] ) ; 
  1650.     else {
  1651.     
  1652.       mem [ r + 5 ] .hh.b0 = 0 ; 
  1653.       mem [ r + 6 ] .gr = 0.0 ; 
  1654.     } 
  1655.     if ( ( totalshrink [ o ] < - (integer) x ) && ( o == 0 ) && ( mem [ r + 5 
  1656.     ] .hh .v.RH != 0 ) ) 
  1657.     {
  1658.       mem [ r + 6 ] .gr = 1.0 ; 
  1659.       if ( ( - (integer) x - totalshrink [ 0 ] > eqtb [ 5710 ] .cint ) || ( 
  1660.       eqtb [ 5294 ] .cint < 100 ) ) 
  1661.       {
  1662.     println () ; 
  1663.     printnl ( 710 ) ; 
  1664.     printscaled ( - (integer) x - totalshrink [ 0 ] ) ; 
  1665.     print ( 711 ) ; 
  1666.     goto lab50 ; 
  1667.       } 
  1668.     } 
  1669.     else if ( ( eqtb [ 5294 ] .cint < 100 ) && ( o == 0 ) && ( mem [ r + 5 ] 
  1670.     .hh .v.RH != 0 ) ) 
  1671.     {
  1672.       b = badness ( - (integer) x , totalshrink [ 0 ] ) ; 
  1673.       if ( b > eqtb [ 5294 ] .cint ) 
  1674.       {
  1675.     println () ; 
  1676.     printnl ( 712 ) ; 
  1677.     printint ( b ) ; 
  1678.     goto lab50 ; 
  1679.       } 
  1680.     } 
  1681.     goto lab10 ; 
  1682.   } 
  1683.   lab50: if ( outputactive ) 
  1684.   print ( 700 ) ; 
  1685.   else {
  1686.       
  1687.     if ( packbeginline != 0 ) 
  1688.     {
  1689.       print ( 702 ) ; 
  1690.       printint ( abs ( packbeginline ) ) ; 
  1691.       print ( 703 ) ; 
  1692.     } 
  1693.     else print ( 704 ) ; 
  1694.     printint ( line ) ; 
  1695.     println () ; 
  1696.   } 
  1697.   begindiagnostic () ; 
  1698.   showbox ( r ) ; 
  1699.   enddiagnostic ( true ) ; 
  1700.   lab10: Result = r ; 
  1701.   return(Result) ; 
  1702. } 
  1703. zappendtovlist ( b ) 
  1704. halfword b ; 
  1705. {appendtovlist_regmem 
  1706.   scaled d  ; 
  1707.   halfword p  ; 
  1708.   if ( curlist .auxfield > -65536000L ) 
  1709.   {
  1710.     d = mem [ eqtb [ 3527 ] .hh .v.RH + 1 ] .cint - curlist .auxfield - mem [ 
  1711.     b + 3 ] .cint ; 
  1712.     if ( d < eqtb [ 5703 ] .cint ) 
  1713.     p = newparamglue ( 0 ) ; 
  1714.     else {
  1715.     
  1716.       p = newskipparam ( 1 ) ; 
  1717.       mem [ tempptr + 1 ] .cint = d ; 
  1718.     } 
  1719.     mem [ curlist .tailfield ] .hh .v.RH = p ; 
  1720.     curlist .tailfield = p ; 
  1721.   } 
  1722.   mem [ curlist .tailfield ] .hh .v.RH = b ; 
  1723.   curlist .tailfield = b ; 
  1724.   curlist .auxfield = mem [ b + 2 ] .cint ; 
  1725. } 
  1726. halfword newnoad () {
  1727.     register halfword Result; newnoad_regmem 
  1728.   halfword p  ; 
  1729.   p = getnode ( 4 ) ; 
  1730.   mem [ p ] .hh.b0 = 16 ; 
  1731.   mem [ p ] .hh.b1 = 0 ; 
  1732.   mem [ p + 1 ] .hh = emptyfield ; 
  1733.   mem [ p + 3 ] .hh = emptyfield ; 
  1734.   mem [ p + 2 ] .hh = emptyfield ; 
  1735.   Result = p ; 
  1736.   return(Result) ; 
  1737. } 
  1738. halfword znewstyle ( s ) 
  1739. smallnumber s ; 
  1740. {register halfword Result; newstyle_regmem 
  1741.   halfword p  ; 
  1742.   p = getnode ( 3 ) ; 
  1743.   mem [ p ] .hh.b0 = 14 ; 
  1744.   mem [ p ] .hh.b1 = s ; 
  1745.   mem [ p + 1 ] .cint = 0 ; 
  1746.   mem [ p + 2 ] .cint = 0 ; 
  1747.   Result = p ; 
  1748.   return(Result) ; 
  1749. } 
  1750. halfword newchoice () {
  1751.     register halfword Result; newchoice_regmem 
  1752.   halfword p  ; 
  1753.   p = getnode ( 3 ) ; 
  1754.   mem [ p ] .hh.b0 = 15 ; 
  1755.   mem [ p ] .hh.b1 = 0 ; 
  1756.   mem [ p + 1 ] .hh .v.LH = 0 ; 
  1757.   mem [ p + 1 ] .hh .v.RH = 0 ; 
  1758.   mem [ p + 2 ] .hh .v.LH = 0 ; 
  1759.   mem [ p + 2 ] .hh .v.RH = 0 ; 
  1760.   Result = p ; 
  1761.   return(Result) ; 
  1762. } 
  1763. showinfo () {
  1764.     showinfo_regmem 
  1765.   shownodelist ( mem [ tempptr ] .hh .v.LH ) ; 
  1766. } 
  1767. halfword zfractionrule ( t ) 
  1768. scaled t ; 
  1769. {register halfword Result; fractionrule_regmem 
  1770.   halfword p  ; 
  1771.   p = newrule () ; 
  1772.   mem [ p + 3 ] .cint = t ; 
  1773.   mem [ p + 2 ] .cint = 0 ; 
  1774.   Result = p ; 
  1775.   return(Result) ; 
  1776. } 
  1777. halfword zoverbar ( b , k , t ) 
  1778. halfword b ; 
  1779. scaled k , t ; 
  1780. {register halfword Result; overbar_regmem 
  1781.   halfword p, q  ; 
  1782.   p = newkern ( k ) ; 
  1783.   mem [ p ] .hh .v.RH = b ; 
  1784.   q = fractionrule ( t ) ; 
  1785.   mem [ q ] .hh .v.RH = p ; 
  1786.   p = newkern ( t ) ; 
  1787.   mem [ p ] .hh .v.RH = q ; 
  1788.   Result = vpackage ( p , 0 , 1 , 1073741823L ) ; 
  1789.   return(Result) ; 
  1790. } 
  1791. halfword zcharbox ( f , c ) 
  1792. internalfontnumber f ; 
  1793. quarterword c ; 
  1794. {register halfword Result; charbox_regmem 
  1795.   fourquarters q  ; 
  1796.   eightbits hd  ; 
  1797.   halfword b, p  ; 
  1798.   q = fontinfo [ charbase [ f ] + c ] .qqqq ; 
  1799.   hd = q .b1 ; 
  1800.   b = newnullbox () ; 
  1801.   mem [ b + 1 ] .cint = fontinfo [ widthbase [ f ] + q .b0 ] .cint + fontinfo 
  1802.   [ italicbase [ f ] + ( q .b2 ) / 4 ] .cint ; 
  1803.   mem [ b + 3 ] .cint = fontinfo [ heightbase [ f ] + ( hd ) / 16 ] .cint ; 
  1804.   mem [ b + 2 ] .cint = fontinfo [ depthbase [ f ] + ( hd ) % 16 ] .cint ; 
  1805.   p = getavail () ; 
  1806.   mem [ p ] .hh.b1 = c ; 
  1807.   mem [ p ] .hh.b0 = f ; 
  1808.   mem [ b + 5 ] .hh .v.RH = p ; 
  1809.   Result = b ; 
  1810.   return(Result) ; 
  1811. } 
  1812. zstackintobox ( b , f , c ) 
  1813. halfword b ; 
  1814. internalfontnumber f ; 
  1815. quarterword c ; 
  1816. {stackintobox_regmem 
  1817.   halfword p  ; 
  1818.   p = charbox ( f , c ) ; 
  1819.   mem [ p ] .hh .v.RH = mem [ b + 5 ] .hh .v.RH ; 
  1820.   mem [ b + 5 ] .hh .v.RH = p ; 
  1821.   mem [ b + 3 ] .cint = mem [ p + 3 ] .cint ; 
  1822. } 
  1823. scaled zheightplusdepth ( f , c ) 
  1824. internalfontnumber f ; 
  1825. quarterword c ; 
  1826. {register scaled Result; heightplusdepth_regmem 
  1827.   fourquarters q  ; 
  1828.   eightbits hd  ; 
  1829.   q = fontinfo [ charbase [ f ] + c ] .qqqq ; 
  1830.   hd = q .b1 ; 
  1831.   Result = fontinfo [ heightbase [ f ] + ( hd ) / 16 ] .cint + fontinfo [ 
  1832.   depthbase [ f ] + ( hd ) % 16 ] .cint ; 
  1833.   return(Result) ; 
  1834. } 
  1835. halfword zvardelimiter ( d , s , v ) 
  1836. halfword d ; 
  1837. smallnumber s ; 
  1838. scaled v ; 
  1839. {/* 40 22 */ register halfword Result; vardelimiter_regmem 
  1840.   halfword b  ; 
  1841.   internalfontnumber f, g  ; 
  1842.   quarterword c, x, y  ; 
  1843.   integer m, n  ; 
  1844.   scaled u  ; 
  1845.   scaled w  ; 
  1846.   fourquarters q  ; 
  1847.   eightbits hd  ; 
  1848.   fourquarters r  ; 
  1849.   smallnumber z  ; 
  1850.   boolean largeattempt  ; 
  1851.   f = 0 ; 
  1852.   w = 0 ; 
  1853.   largeattempt = false ; 
  1854.   z = mem [ d ] .qqqq .b0 ; 
  1855.   x = mem [ d ] .qqqq .b1 ; 
  1856.   while ( true ) {
  1857.       
  1858.     if ( ( z != 0 ) || ( x != 0 ) ) 
  1859.     {
  1860.       z = z + s + 16 ; 
  1861.       do {
  1862.       z = z - 16 ; 
  1863.     g = eqtb [ 4579 + z ] .hh .v.RH ; 
  1864.     if ( g != 0 ) 
  1865.     {
  1866.       y = x ; 
  1867.       lab22: if ( ( y >= fontbc [ g ] ) && ( y <= fontec [ g ] ) ) 
  1868.       {
  1869.         q = fontinfo [ charbase [ g ] + y ] .qqqq ; 
  1870.         if ( ( q .b0 > 0 ) ) 
  1871.         {
  1872.           if ( ( ( q .b2 ) % 4 ) == 3 ) 
  1873.           {
  1874.         f = g ; 
  1875.         c = y ; 
  1876.         goto lab40 ; 
  1877.           } 
  1878.           hd = q .b1 ; 
  1879.           u = fontinfo [ heightbase [ g ] + ( hd ) / 16 ] .cint + fontinfo 
  1880.           [ depthbase [ g ] + ( hd ) % 16 ] .cint ; 
  1881.           if ( u > w ) 
  1882.           {
  1883.         f = g ; 
  1884.         c = y ; 
  1885.         w = u ; 
  1886.         if ( u >= v ) 
  1887.         goto lab40 ; 
  1888.           } 
  1889.           if ( ( ( q .b2 ) % 4 ) == 2 ) 
  1890.           {
  1891.         y = q .b3 ; 
  1892.         goto lab22 ; 
  1893.           } 
  1894.         } 
  1895.       } 
  1896.     } 
  1897.       } while ( ! ( z < 16 ) ) ; 
  1898.     } 
  1899.     if ( largeattempt ) 
  1900.     goto lab40 ; 
  1901.     largeattempt = true ; 
  1902.     z = mem [ d ] .qqqq .b2 ; 
  1903.     x = mem [ d ] .qqqq .b3 ; 
  1904.   } 
  1905.   lab40: if ( f != 0 ) 
  1906.   if ( ( ( q .b2 ) % 4 ) == 3 ) 
  1907.   {
  1908.     b = newnullbox () ; 
  1909.     mem [ b ] .hh.b0 = 1 ; 
  1910.     r = fontinfo [ extenbase [ f ] + q .b3 ] .qqqq ; 
  1911.     c = r .b3 ; 
  1912.     u = heightplusdepth ( f , c ) ; 
  1913.     w = 0 ; 
  1914.     q = fontinfo [ charbase [ f ] + c ] .qqqq ; 
  1915.     mem [ b + 1 ] .cint = fontinfo [ widthbase [ f ] + q .b0 ] .cint + 
  1916.     fontinfo [ italicbase [ f ] + ( q .b2 ) / 4 ] .cint ; 
  1917.     c = r .b2 ; 
  1918.     if ( c != 0 ) 
  1919.     w = w + heightplusdepth ( f , c ) ; 
  1920.     c = r .b1 ; 
  1921.     if ( c != 0 ) 
  1922.     w = w + heightplusdepth ( f , c ) ; 
  1923.     c = r .b0 ; 
  1924.     if ( c != 0 ) 
  1925.     w = w + heightplusdepth ( f , c ) ; 
  1926.     n = 0 ; 
  1927.     if ( u > 0 ) 
  1928.     while ( w < v ) {
  1929.     
  1930.       w = w + u ; 
  1931.       incr ( n ) ; 
  1932.       if ( r .b1 != 0 ) 
  1933.       w = w + u ; 
  1934.     } 
  1935.     c = r .b2 ; 
  1936.     if ( c != 0 ) 
  1937.     stackintobox ( b , f , c ) ; 
  1938.     c = r .b3 ; 
  1939.     {register integer for_end; m = 1 ; for_end = n ; if ( m <= for_end) do 
  1940.       stackintobox ( b , f , c ) ; 
  1941.     while ( m++ < for_end ) ; } 
  1942.     c = r .b1 ; 
  1943.     if ( c != 0 ) 
  1944.     {
  1945.       stackintobox ( b , f , c ) ; 
  1946.       c = r .b3 ; 
  1947.       {register integer for_end; m = 1 ; for_end = n ; if ( m <= for_end) do 
  1948.     stackintobox ( b , f , c ) ; 
  1949.       while ( m++ < for_end ) ; } 
  1950.     } 
  1951.     c = r .b0 ; 
  1952.     if ( c != 0 ) 
  1953.     stackintobox ( b , f , c ) ; 
  1954.     mem [ b + 2 ] .cint = w - mem [ b + 3 ] .cint ; 
  1955.   } 
  1956.   else b = charbox ( f , c ) ; 
  1957.   else {
  1958.       
  1959.     b = newnullbox () ; 
  1960.     mem [ b + 1 ] .cint = eqtb [ 5712 ] .cint ; 
  1961.   } 
  1962.   mem [ b + 4 ] .cint = half ( mem [ b + 3 ] .cint - mem [ b + 2 ] .cint ) - 
  1963.   fontinfo [ 22 + parambase [ eqtb [ 4581 + s ] .hh .v.RH ] ] .cint ; 
  1964.   Result = b ; 
  1965.   return(Result) ; 
  1966. } 
  1967. halfword zrebox ( b , w ) 
  1968. halfword b ; 
  1969. scaled w ; 
  1970. {register halfword Result; rebox_regmem 
  1971.   halfword p  ; 
  1972.   internalfontnumber f  ; 
  1973.   scaled v  ; 
  1974.   if ( ( mem [ b + 1 ] .cint != w ) && ( mem [ b + 5 ] .hh .v.RH != 0 ) ) 
  1975.   {
  1976.     if ( mem [ b ] .hh.b0 == 1 ) 
  1977.     b = hpack ( b , 0 , 1 ) ; 
  1978.     p = mem [ b + 5 ] .hh .v.RH ; 
  1979.     if ( ( ( p >= himemmin ) ) && ( mem [ p ] .hh .v.RH == 0 ) ) 
  1980.     {
  1981.       f = mem [ p ] .hh.b0 ; 
  1982.       v = fontinfo [ widthbase [ f ] + fontinfo [ charbase [ f ] + mem [ p ] 
  1983.       .hh.b1 ] .qqqq .b0 ] .cint ; 
  1984.       if ( v != mem [ b + 1 ] .cint ) 
  1985.       mem [ p ] .hh .v.RH = newkern ( mem [ b + 1 ] .cint - v ) ; 
  1986.     } 
  1987.     freenode ( b , 7 ) ; 
  1988.     b = newglue ( 12 ) ; 
  1989.     mem [ b ] .hh .v.RH = p ; 
  1990.     while ( mem [ p ] .hh .v.RH != 0 ) p = mem [ p ] .hh .v.RH ; 
  1991.     mem [ p ] .hh .v.RH = newglue ( 12 ) ; 
  1992.     Result = hpack ( b , w , 0 ) ; 
  1993.   } 
  1994.   else {
  1995.       
  1996.     mem [ b + 1 ] .cint = w ; 
  1997.     Result = b ; 
  1998.   } 
  1999.   return(Result) ; 
  2000. } 
  2001. halfword zmathglue ( g , m ) 
  2002. halfword g ; 
  2003. scaled m ; 
  2004. {register halfword Result; mathglue_regmem 
  2005.   halfword p  ; 
  2006.   integer n  ; 
  2007.   scaled f  ; 
  2008.   n = xovern ( m , 65536L ) ; 
  2009.   f = remainder ; 
  2010.   p = getnode ( 4 ) ; 
  2011.   mem [ p + 1 ] .cint = nxplusy ( n , mem [ g + 1 ] .cint , xnoverd ( mem [ g 
  2012.   + 1 ] .cint , f , 65536L ) ) ; 
  2013.   mem [ p ] .hh.b0 = mem [ g ] .hh.b0 ; 
  2014.   if ( mem [ p ] .hh.b0 == 0 ) 
  2015.   mem [ p + 2 ] .cint = nxplusy ( n , mem [ g + 2 ] .cint , xnoverd ( mem [ g 
  2016.   + 2 ] .cint , f , 65536L ) ) ; 
  2017.   else mem [ p + 2 ] .cint = mem [ g + 2 ] .cint ; 
  2018.   mem [ p ] .hh.b1 = mem [ g ] .hh.b1 ; 
  2019.   if ( mem [ p ] .hh.b1 == 0 ) 
  2020.   mem [ p + 3 ] .cint = nxplusy ( n , mem [ g + 3 ] .cint , xnoverd ( mem [ g 
  2021.   + 3 ] .cint , f , 65536L ) ) ; 
  2022.   else mem [ p + 3 ] .cint = mem [ g + 3 ] .cint ; 
  2023.   Result = p ; 
  2024.   return(Result) ; 
  2025. } 
  2026.